package demo1;

public class Test {

    public static void main(String[] args) {
        Animal animal=new Bird("小小鸟",20);

        //向下转型，将animal强制类型转换为Bird类型
        Bird bird=(Bird) animal;
        bird.fly();

        Animal animal1=new Dog("旺财",333);
        //animal1这个引用是否引用了Bird这个对象
        if(animal1 instanceof Bird){

            Bird bird1=(Bird) animal1;
            bird.fly();
        }else{
            System.out.println("animal1 instnaceof Bird not!");
        }
    }

    //静态绑定
    //根据用户所传递的实参类型就确定了具体调用的那个方法，即函数重载，也就叫做静态绑定
    public static int add(int a,int b){
        return a+b;
    }

    public static int add(int a,int b,int c){
        return a+b+c;
    }

    public static void main3(String[] args) {
        add(1,2);
        add(1,2,3);
    }

    //animal引用的对象不一样(一个是dog 一个是bird)，但是调用的是同一个方法
    // ，此时表现出的现象不一样，此时这种思想，就叫做多态
    //多态实现条件
    //1.必须是在继承的条件下
    //2.子类必须要对父类中方法进行重写
    //3.通过父类的引用调用重写的方法
    public static void func1(Animal animal){
        animal.eat();
    }

    public static void main2(String[] args) {
        Dog dog=new Dog("wangcai",13);
        func1(dog);
        System.out.println("=============");
        Bird bird=new Bird("xiaoniao",1);
        func1(bird);
    }
    public static void main1(String[] args) {
        //向上转型
        Animal animal=new Dog("小狗",30);
        //动态绑定(虽然Animal父类中有eat方法，但是Dog子类中也有eat方法，
        // 那么animal在调用eat方法的时候，调用的是子类的eat方法，)
        //程序在编译的时候，，调用的是父类的eat方法
        //当运行代码的时候，通过父类引用，调用了父类和子类重写的那个方法，结果实际调用了子类的方法
        animal.eat();


        Dog dog=new Dog("小哈",20);
        dog.bark();
    }

}
